home *** CD-ROM | disk | FTP | other *** search
/ Software of the Month Club 2000 October / Software of the Month - Ultimate Collection Shareware 277.iso / pc / PROGRAMS / UTILITY / WINLINUX / DATA1.CAB / programs_-_include / ASM-M68K / BITOPS.H < prev    next >
Encoding:
C/C++ Source or Header  |  1999-09-17  |  8.2 KB  |  370 lines
  1. #ifndef _M68K_BITOPS_H
  2. #define _M68K_BITOPS_H
  3. /*
  4.  * Copyright 1992, Linus Torvalds.
  5.  *
  6.  * This file is subject to the terms and conditions of the GNU General Public
  7.  * License.  See the file COPYING in the main directory of this archive
  8.  * for more details.
  9.  */
  10.  
  11. /*
  12.  * Require 68020 or better.
  13.  *
  14.  * They use the standard big-endian m680x0 bit ordering.
  15.  */
  16.  
  17. #define test_and_set_bit(nr,vaddr) \
  18.   (__builtin_constant_p(nr) ? \
  19.    __constant_test_and_set_bit(nr, vaddr) : \
  20.    __generic_test_and_set_bit(nr, vaddr))
  21.  
  22. extern __inline__ int __constant_test_and_set_bit(int nr,void * vaddr)
  23. {
  24.     char retval;
  25.  
  26.     __asm__ __volatile__ ("bset %1,%2; sne %0"
  27.          : "=d" (retval)
  28.          : "di" (nr & 7), "m" (((char *)vaddr)[(nr^31) >> 3]));
  29.  
  30.     return retval;
  31. }
  32.  
  33. extern __inline__ int __generic_test_and_set_bit(int nr,void * vaddr)
  34. {
  35.     char retval;
  36.  
  37.     __asm__ __volatile__ ("bfset %2@{%1:#1}; sne %0"
  38.          : "=d" (retval) : "d" (nr^31), "a" (vaddr));
  39.  
  40.     return retval;
  41. }
  42.  
  43. #define set_bit(nr,vaddr) \
  44.   (__builtin_constant_p(nr) ? \
  45.    __constant_set_bit(nr, vaddr) : \
  46.    __generic_set_bit(nr, vaddr))
  47.  
  48. extern __inline__ void __constant_set_bit(int nr, void * vaddr)
  49. {
  50.     __asm__ __volatile__ ("bset %0,%1"
  51.          : : "di" (nr & 7), "m" (((char *)vaddr)[(nr^31) >> 3]));
  52. }
  53.  
  54. extern __inline__ void __generic_set_bit(int nr, void * vaddr)
  55. {
  56.     __asm__ __volatile__ ("bfset %1@{%0:#1}"
  57.          : : "d" (nr^31), "a" (vaddr));
  58. }
  59.  
  60. #define test_and_clear_bit(nr,vaddr) \
  61.   (__builtin_constant_p(nr) ? \
  62.    __constant_test_and_clear_bit(nr, vaddr) : \
  63.    __generic_test_and_clear_bit(nr, vaddr))
  64.  
  65. extern __inline__ int __constant_test_and_clear_bit(int nr, void * vaddr)
  66. {
  67.     char retval;
  68.  
  69.     __asm__ __volatile__ ("bclr %1,%2; sne %0"
  70.          : "=d" (retval)
  71.          : "di" (nr & 7), "m" (((char *)vaddr)[(nr^31) >> 3]));
  72.  
  73.     return retval;
  74. }
  75.  
  76. extern __inline__ int __generic_test_and_clear_bit(int nr, void * vaddr)
  77. {
  78.     char retval;
  79.  
  80.     __asm__ __volatile__ ("bfclr %2@{%1:#1}; sne %0"
  81.          : "=d" (retval) : "d" (nr^31), "a" (vaddr));
  82.  
  83.     return retval;
  84. }
  85.  
  86. #define clear_bit(nr,vaddr) \
  87.   (__builtin_constant_p(nr) ? \
  88.    __constant_clear_bit(nr, vaddr) : \
  89.    __generic_clear_bit(nr, vaddr))
  90.  
  91. extern __inline__ void __constant_clear_bit(int nr, void * vaddr)
  92. {
  93.     __asm__ __volatile__ ("bclr %0,%1"
  94.          : : "di" (nr & 7), "m" (((char *)vaddr)[(nr^31) >> 3]));
  95. }
  96.  
  97. extern __inline__ void __generic_clear_bit(int nr, void * vaddr)
  98. {
  99.     __asm__ __volatile__ ("bfclr %1@{%0:#1}"
  100.          : : "d" (nr^31), "a" (vaddr));
  101. }
  102.  
  103. #define test_and_change_bit(nr,vaddr) \
  104.   (__builtin_constant_p(nr) ? \
  105.    __constant_test_and_change_bit(nr, vaddr) : \
  106.    __generic_test_and_change_bit(nr, vaddr))
  107.  
  108. extern __inline__ int __constant_test_and_change_bit(int nr, void * vaddr)
  109. {
  110.     char retval;
  111.  
  112.     __asm__ __volatile__ ("bchg %1,%2; sne %0"
  113.          : "=d" (retval)
  114.          : "di" (nr & 7), "m" (((char *)vaddr)[(nr^31) >> 3]));
  115.  
  116.     return retval;
  117. }
  118.  
  119. extern __inline__ int __generic_test_and_change_bit(int nr, void * vaddr)
  120. {
  121.     char retval;
  122.  
  123.     __asm__ __volatile__ ("bfchg %2@{%1:#1}; sne %0"
  124.          : "=d" (retval) : "d" (nr^31), "a" (vaddr));
  125.  
  126.     return retval;
  127. }
  128.  
  129. #define change_bit(nr,vaddr) \
  130.   (__builtin_constant_p(nr) ? \
  131.    __constant_change_bit(nr, vaddr) : \
  132.    __generic_change_bit(nr, vaddr))
  133.  
  134. extern __inline__ void __constant_change_bit(int nr, void * vaddr)
  135. {
  136.     __asm__ __volatile__ ("bchg %0,%1"
  137.          : : "di" (nr & 7), "m" (((char *)vaddr)[(nr^31) >> 3]));
  138. }
  139.  
  140. extern __inline__ void __generic_change_bit(int nr, void * vaddr)
  141. {
  142.     __asm__ __volatile__ ("bfchg %1@{%0:#1}"
  143.          : : "d" (nr^31), "a" (vaddr));
  144. }
  145.  
  146. extern __inline__ int test_bit(int nr, const void * vaddr)
  147. {
  148.     return ((1UL << (nr & 31)) & (((const unsigned int *) vaddr)[nr >> 5])) != 0;
  149. }
  150.  
  151. extern __inline__ int find_first_zero_bit(void * vaddr, unsigned size)
  152. {
  153.     unsigned long *p = vaddr, *addr = vaddr;
  154.     unsigned long allones = ~0UL;
  155.     int res;
  156.     unsigned long num;
  157.  
  158.     if (!size)
  159.         return 0;
  160.  
  161.     size = (size >> 5) + ((size & 31) > 0);
  162.     while (*p++ == allones)
  163.     {
  164.         if (--size == 0)
  165.             return (p - addr) << 5;
  166.     }
  167.  
  168.     num = ~*--p;
  169.     __asm__ __volatile__ ("bfffo %1{#0,#0},%0"
  170.                   : "=d" (res) : "d" (num & -num));
  171.     return ((p - addr) << 5) + (res ^ 31);
  172. }
  173.  
  174. extern __inline__ int find_next_zero_bit (void *vaddr, int size,
  175.                       int offset)
  176. {
  177.     unsigned long *addr = vaddr;
  178.     unsigned long *p = addr + (offset >> 5);
  179.     int set = 0, bit = offset & 31UL, res;
  180.  
  181.     if (offset >= size)
  182.         return size;
  183.  
  184.     if (bit) {
  185.         unsigned long num = ~*p & (~0UL << bit);
  186.  
  187.         /* Look for zero in first longword */
  188.         __asm__ __volatile__ ("bfffo %1{#0,#0},%0"
  189.                       : "=d" (res) : "d" (num & -num));
  190.         if (res < 32)
  191.             return (offset & ~31UL) + (res ^ 31);
  192.                 set = 32 - bit;
  193.         p++;
  194.     }
  195.     /* No zero yet, search remaining full bytes for a zero */
  196.     res = find_first_zero_bit (p, size - 32 * (p - addr));
  197.     return (offset + set + res);
  198. }
  199.  
  200. /*
  201.  * ffz = Find First Zero in word. Undefined if no zero exists,
  202.  * so code should check against ~0UL first..
  203.  */
  204. extern __inline__ unsigned long ffz(unsigned long word)
  205. {
  206.     int res;
  207.  
  208.     __asm__ __volatile__ ("bfffo %1{#0,#0},%0"
  209.                   : "=d" (res) : "d" (~word & -~word));
  210.     return res ^ 31;
  211. }
  212.  
  213. #ifdef __KERNEL__
  214.  
  215. /*
  216.  * ffs: find first bit set. This is defined the same way as
  217.  * the libc and compiler builtin ffs routines, therefore
  218.  * differs in spirit from the above ffz (man ffs).
  219.  */
  220.  
  221. extern __inline__ int ffs(int x)
  222. {
  223.     int cnt;
  224.  
  225.     asm ("bfffo %1{#0:#0}" : "=d" (cnt) : "dm" (x & -x));
  226.  
  227.     return 32 - cnt;
  228. }
  229.  
  230. /*
  231.  * hweightN: returns the hamming weight (i.e. the number
  232.  * of bits set) of a N-bit word
  233.  */
  234.  
  235. #define hweight32(x) generic_hweight32(x)
  236. #define hweight16(x) generic_hweight16(x)
  237. #define hweight8(x) generic_hweight8(x)
  238.  
  239. /* Bitmap functions for the minix filesystem */
  240.  
  241. extern __inline__ int
  242. minix_find_first_zero_bit (const void *vaddr, unsigned size)
  243. {
  244.     const unsigned short *p = vaddr, *addr = vaddr;
  245.     int res;
  246.     unsigned short num;
  247.  
  248.     if (!size)
  249.         return 0;
  250.  
  251.     size = (size >> 4) + ((size & 15) > 0);
  252.     while (*p++ == 0xffff)
  253.     {
  254.         if (--size == 0)
  255.             return (p - addr) << 4;
  256.     }
  257.  
  258.     num = ~*--p;
  259.     __asm__ __volatile__ ("bfffo %1{#16,#16},%0"
  260.                   : "=d" (res) : "d" (num & -num));
  261.     return ((p - addr) << 4) + (res ^ 31);
  262. }
  263.  
  264. extern __inline__ int
  265. minix_set_bit (int nr, void *vaddr)
  266. {
  267.     char retval;
  268.  
  269.     __asm__ __volatile__ ("bfset %2{%1:#1}; sne %0"
  270.          : "=d" (retval) : "d" (nr^15), "m" (*(char *)vaddr));
  271.  
  272.     return retval;
  273. }
  274.  
  275. extern __inline__ int
  276. minix_clear_bit (int nr, void *vaddr)
  277. {
  278.     char retval;
  279.  
  280.     __asm__ __volatile__ ("bfclr %2{%1:#1}; sne %0"
  281.          : "=d" (retval) : "d" (nr^15), "m" (*(char *) vaddr));
  282.  
  283.     return retval;
  284. }
  285.  
  286. extern __inline__ int
  287. minix_test_bit (int nr, const void *vaddr)
  288. {
  289.     return ((1U << (nr & 15)) & (((const unsigned short *) vaddr)[nr >> 4])) != 0;
  290. }
  291.  
  292. /* Bitmap functions for the ext2 filesystem. */
  293.  
  294. extern __inline__ int
  295. ext2_set_bit (int nr, void *vaddr)
  296. {
  297.     char retval;
  298.  
  299.     __asm__ __volatile__ ("bfset %2{%1,#1}; sne %0"
  300.          : "=d" (retval) : "d" (nr^7), "m" (*(char *) vaddr));
  301.  
  302.     return retval;
  303. }
  304.  
  305. extern __inline__ int
  306. ext2_clear_bit (int nr, void *vaddr)
  307. {
  308.     char retval;
  309.  
  310.     __asm__ __volatile__ ("bfclr %2{%1,#1}; sne %0"
  311.          : "=d" (retval) : "d" (nr^7), "m" (*(char *) vaddr));
  312.  
  313.     return retval;
  314. }
  315.  
  316. extern __inline__ int
  317. ext2_test_bit (int nr, const void *vaddr)
  318. {
  319.     return ((1U << (nr & 7)) & (((const unsigned char *) vaddr)[nr >> 3])) != 0;
  320. }
  321.  
  322. extern __inline__ int
  323. ext2_find_first_zero_bit (const void *vaddr, unsigned size)
  324. {
  325.     const unsigned long *p = vaddr, *addr = vaddr;
  326.     int res;
  327.  
  328.     if (!size)
  329.         return 0;
  330.  
  331.     size = (size >> 5) + ((size & 31) > 0);
  332.     while (*p++ == ~0UL)
  333.     {
  334.         if (--size == 0)
  335.             return (p - addr) << 5;
  336.     }
  337.  
  338.     --p;
  339.     for (res = 0; res < 32; res++)
  340.         if (!ext2_test_bit (res, p))
  341.             break;
  342.     return (p - addr) * 32 + res;
  343. }
  344.  
  345. extern __inline__ int
  346. ext2_find_next_zero_bit (const void *vaddr, unsigned size, unsigned offset)
  347. {
  348.     const unsigned long *addr = vaddr;
  349.     const unsigned long *p = addr + (offset >> 5);
  350.     int bit = offset & 31UL, res;
  351.  
  352.     if (offset >= size)
  353.         return size;
  354.  
  355.     if (bit) {
  356.         /* Look for zero in first longword */
  357.         for (res = bit; res < 32; res++)
  358.             if (!ext2_test_bit (res, p))
  359.                 return (p - addr) * 32 + res;
  360.         p++;
  361.     }
  362.     /* No zero yet, search remaining full bytes for a zero */
  363.     res = ext2_find_first_zero_bit (p, size - 32 * (p - addr));
  364.     return (p - addr) * 32 + res;
  365. }
  366.  
  367. #endif /* __KERNEL__ */
  368.  
  369. #endif /* _M68K_BITOPS_H */
  370.